package user

import (
	"fmt"
	"github.com/gin-gonic/gin"
	"gorm.io/gorm"
	"math/rand"
	"path/filepath"
	"shejiao/base"
	common3 "shejiao/common/model/common"
	user22 "shejiao/common/model/user"
	"shejiao/common/request"
	user2 "shejiao/common/service/user"
	common2 "shejiao/pkg/common"
	"shejiao/pkg/util"
	"time"
)

var Common = common{}

type common struct {
	orm *gorm.DB
}

// @summary 获取个人信息
// @tags 授权接口
// @Param token header string true "认证token"
// @Router /api/user/index [post]
func (co *common) Index(c *gin.Context) {
	roleId := util.GetRoleId(c)

	// 开始匹配 搜索在线人数
	now := time.Now()
	y, m, d := int64(now.Year()), int64(now.Month()), int64(now.Day())
	chatCnt := user2.UserMatchRecorderService.HaveBeenChatCnt(roleId, y, m, d)
	calledCnt := user2.UserMatchRecorderService.HaveBeenCalledCnt(roleId, y, m, d)

	// 用户信息
	var ui user22.UserInfo
	base.Mysql.Find(&ui, "user_id = ?", roleId)

	// 配置信息
	var cnf []common3.Config
	base.Mysql.Find(&cnf, "is_show_front = 1")

	ri := rand.Intn(14)
	heads := []string{}
	host := base.Config.App.Domain
	for i := 0; i < 6; i++ {
		heads = append(heads, fmt.Sprintf("%s/uploads/head/%dhead.jpg", host, ri+i))
	}

	// 用户相关信息
	resp := gin.H{"user": ui, "match_called_cnt": calledCnt, "match_chat_cnt": chatCnt, "config": cnf, "heads": heads}
	common2.Response.Success(c, resp)
}

// @summary 系统消息列表
// @tags 公共
// @Description 系统消息列表
// @Accept json
// @Produce json
// @Param token header string true "认证token"
// @Param   page  query    int  true  "分页"
// @Param   limit  query    int  true  "条数"
// @Router /api/user/common/system_notice [post]
func (co *common) SystemNotice(c *gin.Context) {
	var req request.PageLimit
	err := c.ShouldBind(&req)
	if err != nil {
		common2.Response.Error(c, err.Error(), gin.H{})
		return
	}

	roleId := util.GetRoleId(c)
	var notice []common3.SystemNotice
	base.Mysql.Model(&common3.SystemNotice{}).Offset(req.GetOffset()).Limit(req.GetLimit()).Find(&notice, "user_id = ?", roleId)
	common2.Response.Success(c, gin.H{"page": req.Page, "limit": req.Limit, "list": notice})
}

// @summary 举报用户
// @tags 公共
// @Description 系统消息列表
// @Accept json
// @Produce json
// @Param token header string true "认证token"
// @Param   name  body    string  true  "举报类型"
// @Param   to  body    int  true  "举报人"
// @Router /api/user/common/report [post]
func (co *common) Report(c *gin.Context) {
	var req struct {
		Name string `json:"name"`
		To   int64  `json:"to"`
	}
	err := c.ShouldBind(&req)
	if err != nil {
		common2.Response.Error(c, err.Error(), gin.H{})
		return
	}

	now := time.Now()
	roleId := util.GetRoleId(c)
	base.Mysql.Create(&common3.Report{Name: req.Name, Form: roleId, To: req.To, CreateAt: now.Unix()})
	common2.Response.Success(c, gin.H{})
}

// @summary 举报记录
// @tags 公共
// @Description 系统消息列表
// @Accept json
// @Produce json
// @Param token header string true "认证token"
// @Router /api/user/common/report_recorder [post]
func (co *common) ReportRecorder(c *gin.Context) {
	var list []common3.Report
	roleId := util.GetRoleId(c)
	base.Mysql.Find(&list, "form = ?", roleId)
	common2.Response.Success(c, gin.H{"list": list})
}

// @summary 上传文件
// @tags 公共
// @Description 系统消息列表
// @Accept json
// @Produce json
// @Param token header string true "认证token"
// @Param file formData file true "File"
// @Router /api/user/common/upload [post]
func (co *common) Upload(c *gin.Context) {
	file, err := c.FormFile("file")
	if err != nil {
		// 如果有错误，则返回HTTP状态码400和错误信息
		common2.Response.Error(c, "获取文件失败", gin.H{"err": err.Error()})
		return
	}

	now := time.Now()

	ymd := fmt.Sprintf("%d%d%d", now.Year(), now.Month(), now.Day())
	extension := filepath.Ext(file.Filename)
	roleId := util.GetRoleId(c)

	fileName := fmt.Sprintf("/uploads/%s/%d_%d_%d%s", ymd, now.Second(), roleId, rand.Intn(999999), extension)
	if err = c.SaveUploadedFile(file, "./common"+fileName); err != nil {
		common2.Response.Error(c, "保存文件错误", gin.H{"err": err.Error()})
		return
	}

	common2.Response.Success(c, gin.H{"filename": fileName})

}

// @summary 开发者建议提交
// @tags 公共
// @Description 系统消息列表
// @Accept json
// @Produce json
// @Param token header string true "认证token"
// @Param   name  query     string  true  "建议类型"
// @Param   content  query    string  true  "建议描述"
// @Param   images  query    string  true  "建议图片"
// @Param   pid  query    int  true  "建议回复ID"
// @Router /api/user/common/suggest [post]
func (co *common) Suggest(c *gin.Context) {
	var req struct {
		Name    string `json:"name"`
		Content string `json:"content"`
		Images  string `json:"images"`
		Pid     int64  `json:"pid"`
	}
	err := c.ShouldBind(&req)
	if err != nil {
		common2.Response.Error(c, "参数有误", gin.H{"err": err.Error()})
		return
	}

	roleId := util.GetRoleId(c)
	now := time.Now()
	base.Mysql.Create(&common3.Suggest{Name: req.Name, Type: "user", Pid: req.Pid, Content: req.Content, Images: req.Images, UserId: roleId, CreateAt: now.Unix()})
	common2.Response.Success(c, gin.H{})
	return
}

// @summary 开发者建议记录
// @tags 公共
// @Description 系统消息列表
// @Accept json
// @Produce json
// @Param token header string true "认证token"
// @Param   pid  query    int  true  "建议回复ID"
// @Router /api/user/common/suggest_recorder [post]
func (co *common) SuggestRecorder(c *gin.Context) {
	var req struct {
		Pid int64 `json:"pid"`
	}
	c.ShouldBind(&req)

	roleId := util.GetRoleId(c)
	var list []common3.Suggest
	if req.Pid != 0 {
		base.Mysql.Find(&list, "user_id = ? and pid = ?", roleId, req.Pid)
	} else {
		base.Mysql.Find(&list, "user_id = ?", roleId)
	}
	common2.Response.Success(c, gin.H{"list": list})
}

// @summary 匹配回调
// @tags 匹配
// @Description 系统消息列表
// @Accept json
// @Produce json
// @Param   user_id  body  int  true  "用户ID"
// @Router /api/common/callback/login [post]
func (co *common) CallbackLogin(c *gin.Context) {
	var req struct {
		Appid        string `json:"appid"`         // appid
		Event        string `json:"event"`         // 回调事件，此回调返回值为 user_action。
		Timestamp    int64  `json:"timestamp"`     // callback服务器当前时间 Uinx 时间戳，单位为秒。
		Nonce        string `json:"nonce"`         // 随机数。
		Signature    string `json:"signature"`     // 检验串，详情见 检验说明 。
		UserID       string `json:"user_id"`       // 用户 ID。
		UserName     string `json:"user_name"`     // 用户昵称。
		Os           string `json:"os"`            // 操作系统说明，用户上线时同步。包含以下枚举：
		Action       int    `json:"action"`        // 状态：0(登录)，1(登出)，2(离线)。
		SessionID    string `json:"session_id"`    // 一个连接的唯一 ID。如果同一用户在多端同时在线，则会有多个连接，可使用此 ID 进行区分。
		LoginTime    int64  `json:"login_time"`    // 登录时间 Uinx时间戳， 单位为秒。
		Relogin      int    `json:"relogin"`       // 重新登录标识。0：首次登录。1：重新登录。
		LogoutTime   int64  `json:"logout_time"`   // 登出时间 Uinx时间戳， 单位为秒。
		LogoutReason string `json:"logout_reason"` // 登出原因
		OfflineTime  int64  `json:"offline_time"`  // 离线时间 Uinx时间戳， 单位为秒。
	}

	err := c.ShouldBind(&req)
	if err != nil {
		common2.Response.Error(c, err.Error(), gin.H{})
		return
	}

	// 格式化输出
	fmt.Println("CallbackLogin", req)

	// 查询用户信息
	var userInfo user22.UserInfo
	err = base.Mysql.Where("user_id = ?", req.UserID).First(&userInfo).Error
	if err != nil {
		common2.Response.Error(c, "用户不存在", gin.H{})
		return
	}

	// 上线
	if req.Action == 0 {
		base.UserMatchManagerRegion.Online(userInfo.UserId, userInfo.Province)
	}

	// 下线
	if req.Action == 1 || req.Action == 2 {
		base.UserMatchManagerRegion.Leave(userInfo.UserId, userInfo.Province)
	}

	common2.Response.Success(c, gin.H{})
}

// @summary 区域列表
// @tags 匹配
// @Description 系统消息列表
// @Accept json
// @Produce json
// @Param token header string true "认证token"
// @Router /api/common/region [post]
func (co *common) Region(c *gin.Context) {
	var list []common3.Region
	base.Mysql.Find(&list)
	common2.Response.Success(c, gin.H{"list": list})
}
